#ifndef __MATH_H
#define __MATH_H

#include <cmath>
#include <cfloat>

// define the standard trig values
#ifdef PI
#undef PI
#undef PI_2
#undef PI_4
#endif
const double PI   = 3.14159265358979323846;
const double PI_2 = 1.57079632679489661923;
const double PI_4 = 0.78539816339744830962;
const double LN_2 = 0.69314718055994530942;
const double INVLN_2 = 1.0 / LN_2;


/** return the minimum of two values, equivalent to std::min.
  * std::min not used because of STL implementation under IRIX not
  * containing std::min.
*/
template<typename T>
inline T TMT_absolute(T v) { return v<(T)0?-v:v; }

/** return true if float lhs and rhs are equivalent,
  * meaning that the difference between them is less than an epsilon value
  * which defaults to 1e-6.
*/
inline bool TMT_equivalent(float lhs,float rhs,float epsilon=1e-6)
  { float delta = rhs-lhs; return delta<0.0f?delta>=-epsilon:delta<=epsilon; }

/** return true if double lhs and rhs are equivalent,
  * meaning that the difference between them is less than an epsilon value
  * which defaults to 1e-6.
*/
inline bool TMT_equivalent(double lhs,double rhs,double epsilon=1e-6)
  { double delta = rhs-lhs; return delta<0.0?delta>=-epsilon:delta<=epsilon; }

/** return the minimum of two values, equivalent to std::min.
  * std::min not used because of STL implementation under IRIX not containing
  * std::min.
*/
template<typename T>
inline T TMT_minimum(T lhs,T rhs) { return lhs<rhs?lhs:rhs; }

/** return the maximum of two values, equivalent to std::max.
  * std::max not used because of STL implementation under IRIX not containing
  * std::max.
*/
template<typename T>
inline T TMT_maximum(T lhs,T rhs) { return lhs>rhs?lhs:rhs; }

template<typename T>
inline T TMT_clampTo(T v,T minimum,T maximum) { return v<minimum?minimum:v>maximum?maximum:v; }

template<typename T>
inline T TMT_clampAbove(T v,T minimum) { return v<minimum?minimum:v; }

template<typename T>
inline T TMT_clampBelow(T v,T maximum) { return v>maximum?maximum:v; }

template<typename T>
inline T TMT_clampBetween(T v,T minimum, T maximum)
  { return TMT_clampBelow(TMT_clampAbove(v,minimum),maximum); }

template<typename T>
inline T TMT_sign(T v) { return v<(T)0?(T)-1:(T)1; }

template<typename T>
inline T TMT_signOrZero(T v) { return v<(T)0 ? (T)-1 : ( v>(T)0 ? (T)1 : 0 ); }

template<typename T>
inline T TMT_square(T v) { return v*v; }

template<typename T>
inline T TMT_signedSquare(T v) { return v<(T)0?-v*v:v*v;; }

inline float TMT_inDegrees(float angle) { return angle*(float)PI/180.0f; }
inline double TMT_inDegrees(double angle) { return angle*PI/180.0; }

template<typename T>
inline T TMT_inRadians(T angle) { return angle; }

inline float TMT_DegreesToRadians(float angle) { return angle*(float)PI/180.0f; }
inline double TMT_DegreesToRadians(double angle) { return angle*PI/180.0; }

inline float TMT_RadiansToDegrees(float angle) { return angle*180.0f/(float)PI; }
inline double TMT_RadiansToDegrees(double angle) { return angle*180.0/PI; }

// inline float TMT_round(float v) { return v>=0.0f?floorf(v+0.5f):ceilf(v-0.5f); }
// inline double TMT_round(double v) { return v>=0.0?floor(v+0.5):ceil(v-0.5); }

#if defined(_MSC_VER)
    inline bool TMT_isNaN(double v) { return _isnan(v)!=0; }
#elif defined(__ANDROID__)
    inline bool TMT_isNaN(float v) { return isnan(v); }
    inline bool TMT_isNaN(double v) { return isnan(v); }
#else
    inline bool TMT_isNaN(float v) { return std::isnan(v); }
    inline bool TMT_isNaN(double v) { return std::isnan(v); }
#endif


#endif  // __OSG_MATH

